1. Field of the Invention
The present invention relates to Computer Aided Software Engineering (CASE) environments, and more specifically, to the use of software development and configuration management tools in a development environment that supports multiple concurrent users and simultaneous use of various versions of software configuration items by caching source and object code items.
2. Description of Related Art
In the last decade, the use of a Computer Aided Software Engineering (CASE) environment as a software development tool has evolved from being merely helpful to nearly essential, particularly for large or complex software systems. An effective CASE environment enables companies to exercise configuration management and version control over their software products, from the individual item level through the system level. Additionally, an effective CASE environment simplifies and supports efficient software design, by providing a library or storehouse of previously developed software items and modules that can be re-used, modified, expanded, or reconfigured as required to support development of upgrades, new applications, or new systems. The most useful CASE tools are capable of selecting identified items and modules, inserting required modifications, adding new items, and building software systems, all according to a software developer""s instructions. Well-known CASE systems that execute these functions include UNIX/PWB, which includes the SCCS source code control system and the MAKE configuration tool; RCS; and CMS and MMS, which are essentially the VAX/VMS equivalent of SCCS and MAKE.
While these systems are powerful development tools, they also have inherent limitations that create problems, particularly when the company""s software configuration library and the CASE system is shared by a group of designers over the company""s internal network. To facilitate the design process, companies typically want their software developers to have ready access to the proper development tools, software library, and indeed, each others"" files. However, when multiple users working at different workstations on the company""s network simultaneously select files, add modifications, and build systems, the company""s computing resources may be stretched beyond their limit. This is particularly a problem if multiple users"" simultaneous system builds require computation-intensive recompilation and linking.
A related problem that arises in the development environment described above occurs when multiple users try to access the same item from the library. Some of the CASE systems described above also function as xe2x80x9cgatekeepersxe2x80x9d to the company""s software libraryxe2x80x94they preclude two different designers from making changes simultaneously to a single library item, or they prohibit access and/or changes to xe2x80x9coldxe2x80x9d versions of a library item. While this xe2x80x9cgatekeepingxe2x80x9d feature is useful from a configuration management standpoint, it limits design flexibility in many current CASE systems.
To overcome the above limitations in networked development environment, software designers working on a single system (or potentially overlapping portions of a single system) have typically worked with a local copy of the entire system and local copies of all incorporated library source and object code itemsxe2x80x94including items required for periodic rebuilding, even if those items are not actively being worked on. As the number of users grows, the number of files duplicated across all the designers"" workstations grows. This duplication wastes computing resources, storage space, and designers"" time because it slows down the entire development environment. Also, when the networked system is tasked with two or more parallel local builds, the vast majority of each designer""s local object files may be bitwise identical to other designers"" local object files, if the designers are working on the same system or have made only minor changes to a small number of local source files.
These problems with current CASE systems demonstrate the need for a software development system that is optimized for multiple simultaneous users in a networked development environment. Moreover, in an optimal software development system, gatekeeping functions would not limit design flexibility to the extent that designers feel forced to create, maintain, and periodically re-build their own local, nearly-identical systems. The present invention is a CASE system and design environment that overcomes the above limitations of current CASE systems. In the present invention, source and object files are cached, registered, and shared by multiple designers working at multiple workstations, thus avoiding needless and resource-intensive replication and storage of common, shared files into redundant identical local files. This sharing of common files eliminates wasted space and computing resources associated with duplicative local files, avoids needless simultaneous local recompiling and rebuilding, and reduces system inefficiencies.
The present invention is a method and apparatus for building a software system, preferably in a software development environment comprising networked software development computer workstations wherein multiple workstations have access to one or more network caches. The present invention works with currently available software configuration control and building programs, such as RCS and MAKE.
A practitioner of the present invention lists each source file (by name and version number) and each explicit object file (by name) that comprise the software system to be built, and from that build list, the present invention generates a cache link structure. The cache link structure is a system of source file links, and, to the maximum extent possible, object file links, preferably constructed it in a directory tree that the present invention is capable of generating. Source file links associate source file names and versions listed on the build list to a copy of the corresponding source file stored in the network cache memory. Object file links are links from explicit object file names and potentially usable object file names to corresponding copies of the object file stored in a network cache memory. Explicit object file names are object files expressly named on the build list. Potentially usable object file names are file names generated by the present invention during the process of creating source file links. The present invention provides the cache link structure to a software building program such as MAKE. To the extent that files need to be reconstructed because of changes, MAKE then builds the software system using the links to the cached copies of the constituent files.
The present invention utilizes a source and object file naming convention and identification scheme to facilitate file identification and searching the network caches and creating the links to cached source and object files. Source files are cached under their filenames and version numbers. Object files are cached under their filenames, along with a random string of characters, which allows multiple versions of the same basic object file to simultaneously exist in the cache. Object files also contain an embedded character string that identifies all source files, along with their version numbers, that were used to generate the object file.
When searching the cache to locate the proper version of an object file to create a link to, the present invention examines object files with the same basic name as the target object file, in age order (most recently created or accessed first), When the present invention locates a cached object file with the same basic name as the target object file that also contains an internal embedded identification string that identifies only constituent source files and versions that are also listed on the build list, the present invention creates a link to that object file.
To facilitate searching the cache for object files, the present invention supports the creation and caching of identification files. Each identification file corresponds to a specific object file in the cache, but contains only the embedded identification string from its corresponding object file. The name of each identification file is identical to its corresponding cached object file, except that an additional file extension that identifies the file, as an identification file is appended to the identification file name. The use of the identification file enables quicker searching for object files during the linking process of the present invention.